Data streams, containing data elements that originate from different data sources, are frequently transmitted in data nets. The data elements of the different data sources are then arranged sequentially in a data stream. The data elements are sent to processing in the sequence in which they are present in the data stream.
During processing of the data elements, execution of very simple, lightweight instructions can be involved. A stipulated sequence of such instructions is referred to as a thread. During processing of the data elements of a data stream, different threads are generally processed. Which thread is processed at which time generally depends on the properties of the data element that is foremost on the data stream at this time. The choice of thread depends, in particular, on the data source, from which the data element to be processed originates. For this purpose, data elements are often provided with an identification number that characterizes their corresponding data source. The allocated thread can be identified by means of this identification number.
Each thread is assigned its own context. The context contains information concerning the state, in which processing of the thread at the present time is situated. Before the beginning of execution of a thread, the first instruction to be executed in the thread can be entered in the registers allocated to the context. After the beginning of execution of the thread, these registers can be overwritten with the actual instructions of the thread.
A device that assigns the instruction from the corresponding thread, prescribed for an incoming data element, and decodes this instruction is necessary for processing of data elements, so that a component connected after this device, which carries out actual processing of the data element, can be supplied control signals for processing.
Ordinary devices that fulfill the purpose just mentioned are based either on software solutions that run on a digital signal processor, or on hardware solutions. However, software solutions are rather inefficient for byte-byte-processing. Hardware solutions have the drawback of limited flexibility with respect to protocol changes.